#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
#include <deque>
#include <list>
#include <algorithm>
#include "Stack.h"
#include "Queue.h"
using namespace std;
void test_stack()
{
	//rtx::stack<int, vector<int>> st;
	//rtx::stack<int, list<int>> st;
	rtx::stack<int> st;

	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);

	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
}

void test_queue()
{
	//rtx::queue<int> q;
	rtx::queue<int, list<int>> q;

	// 不支持 vector没有pop_front
	//bit::queue<int, vector<int>> q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.push(4);

	while (!q.empty())
	{
		cout << q.front() << " ";
		q.pop();
	}
	cout << endl;
}

void test_op()
{
	srand(time(0));
	const int N = 100000;
	vector<int> v;
	v.reserve(N);

	/*list<int> lt1;
	list<int> lt2;*/

	deque<int> dp;
	//deque<int> lt1;
	//deque<int> lt2;

	for (int i = 0; i < N; ++i)
	{
		auto e = rand();
		v.push_back(e);
		dp.push_back(e);

		//lt1.push_back(e);
		//lt2.push_back(e);
	}

	// 拷贝到vector排序，排完以后再拷贝回来
	int begin1 = clock();
	sort(v.begin(), v.end());
	int end1 = clock();

	int begin2 = clock();
	sort(dp.begin(), dp.end());
	int end2 = clock();

	printf("vector sort:%d\n", end1 - begin1);
	printf("deque sort:%d\n", end2 - begin2);
}

int main()
{
	test_stack();
	test_queue();

	return 0;
}

// 仿函数/函数对象  -- 类，重载operator()
// 类对象可以像函数一样去使用
//namespace bit
//{
//	/*class less
//	{
//	public:
//	bool operator()(const int& l, const int& r) const
//	{
//	return l < r;
//	}
//	};*/
//
//	template<class T>
//	class less
//	{
//	public:
//		bool operator()(const T& l, const T& r) const
//		{
//			return l < r;
//		}
//	};
//
//	template<class T>
//	class greater
//	{
//	public:
//		bool operator()(const T& l, const T& r) const
//		{
//			return l > r;
//		}
//	};
//}
//
//int main()
//{
//	bit::less<int> lsFunc;
//
//	cout << lsFunc(1, 2) << endl;
//	// 等价于下面
//	//cout << lsFunc.operator()(1, 2) << endl;
//
//	bit::greater<int> gtFunc;
//
//	cout << gtFunc(1, 2) << endl;
//
//
//	return 0;
//}

//
//#include <iostream>
//#include <stack>
//#include <queue>
//#include <vector>
//#include <list>
//#include <algorithm>
//#include <functional>
//#include <time.h>
//#include <string>
//using namespace std;
//
//class Solution {
//public:
//    bool IsPopOrder(vector<int> pushed, vector<int> popped) {
//        if (pushed.size() != popped.size())
//        {
//            return false;
//        }
//        stack<int> st;
//        int popi = 0;
//        for (const auto& e : pushed)
//        {
//            st.push(e);//不匹配就持续入，匹配就持续出
//            while (!st.empty() && st.top() == popped[popi])
//            {
//                st.pop();
//                ++popi;
//            }
//        }
//        //return popi == popped.size();
//        return st.empty();
//    }
//};
//
////1 操作数入栈
////2 遇到操作符就取栈顶两个操作数运算
//class Solution {
//public:
//    int evalRPN(vector<string>& tokens) {
//        stack<int> st;
//        for (auto& e : tokens)
//        {
//            if (e == "+" || e == "-" || e == "*" || e == "/")
//            {
//                int right = st.top();//右操作数先出栈
//                st.pop();
//                int left = st.top();
//                st.pop();
//
//                switch (e[0])
//                {
//                case '+':
//                    st.push(left + right);
//                    break;
//                case '-':
//                    st.push(left - right);
//                    break;
//                case '*':
//                    st.push(left * right);
//                    break;
//                case '/':
//                    st.push(left / right);
//                    break;
//                }
//            }
//            else
//            {
//                st.push(stoi(e));
//            }
//        }
//        return st.top();
//    }
//};